//@include lib_Class.js
// Nashorn
if (typeof Java != "undefined") {
Object.defineProperty(this, "global", {
configurable: true, enumerable: false, writable: true,
value: this
});
}
/**
* Utility methods for the ELOas.
*
* @author PZ, ELO Digital Office GmbH
* @version 1.0
*
* @eloas
*/
sol.define("sol.common.as.Utils", {
singleton: true,
/**
* Checks if the current execution is in an users context and throws an exception if that is not the case.
*
* If an EM_USERID is set, `ixConnect` will be initialized for this user, while the original connection will be availabe via `ixConnectAdmin`.
*
* @param {Object} scope The ruleset object
*/
requiresUserSession: function (scope) {
var me = this,
param3Obj, logTicket, ticketUserId;
try {
param3Obj = JSON.parse(EM_PARAM3 || "{}");
} catch (ex) {
// ignore
}
param3Obj = param3Obj || {};
if (param3Obj.ticket) {
logTicket = param3Obj.ticket.substr(0, 10) + "...";
if (ixConnect.loginResult.clientInfo.ticket == param3Obj.ticket) {
me.logger.debug(["User ticket corresponds to ELOas service ticket: ticket={0}", logTicket]);
return;
}
ticketUserId = sol.common.UserUtils.getUserIdFromTicket(param3Obj.ticket);
me.logger.debug(["Set current user from user ticket: ticket={0}, userId={1}", logTicket, ticketUserId]);
EM_USERID = ticketUserId;
}
if (EM_USERID === -1) {
throw "user ticket required";
}
if (typeof Java != "undefined") {
global.ixConnectAdmin = ixConnect; // Nashorn
} else {
scope.__parent__.ixConnectAdmin = ixConnect; // Rhino
}
try {
me.ensureRelogin(ixConnectAdmin);
ixConnect = ixConnectAdmin.createConnectionForUser(EM_USERID);
} catch (ex) {
ixConnectAdmin = undefined;
me.logger.error(["Error creating connection for user '{0}'", EM_USERID], ex);
throw "Executing ELOas rules in the current users context is not supported by this AM version. 'CreateConnectionForUser' does not support local ELO accounts if LDAP is used for authentification.";
}
if (param3Obj.language) {
ixConnect.loginResult.clientInfo.language = param3Obj.language;
}
if (param3Obj.timeZone) {
ixConnect.loginResult.clientInfo.timeZone = param3Obj.timeZone;
} else {
me.logger.warn("The given time zone should not be empty.");
}
me.logger.info(["User session: user.id={0}, user.name={1}, language={2}, timeZone={3}, callId={4}]", ixConnect.loginResult.user.id + "", ixConnect.loginResult.user.name + "", ixConnect.loginResult.clientInfo.language + "", ixConnect.loginResult.clientInfo.timeZone + "", ixConnect.loginResult.clientInfo.callId + ""]);
},
/**
* @private
* Ensure a re-login if necessary
* @param {de.elo.ix.client.IXConnection} [conn=ixConnect] Connection
*/
ensureRelogin: function (conn) {
conn = conn || ixConnect;
conn.ix().createSord("0", "", EditInfoC.mbOnlyId);
},
/**
* Changed connection settings (see {@link #requiresUserSession}) will be reseted and the user connection will be closed.
*/
cleanupUserSession: function () {
if (typeof ixConnectAdmin !== "undefined") {
if (ixConnect !== ixConnectAdmin) { // do only reset if 'ixConnect' was created by 'requiresUserSession'
ixConnect.close();
ixConnect = ixConnectAdmin;
}
ixConnectAdmin = undefined; // always reset ixConnectAdmin variable
}
},
/**
* Executes an function
* @param {String} funcName Function name
* @param {Object} config Configuration
* @param {Object} config.params Parameters
* @param {Object} [config.adminOnly=false] If true then the function can only be called by an user with administrative rights
* @param {Boolean} config.rawResult Returns the raw result
*/
executeFunction: function (funcName, config) {
var me = this,
func, result;
if (!funcName) {
throw "Function name is empty";
}
config = config || {};
me.logger = sol.create("sol.Logger", { scope: "sol.common.as.Utils" });
if (!config.params) {
if (!EM_PARAM2) {
me.logger.info("EM_PARAM2 is empty.");
return;
}
try {
config.params = JSON.parse(EM_PARAM2);
} catch (ex) {
me.logger.info("Can't parse configuration: EM_PARAM2=" + EM_PARAM2);
return;
}
}
me.logger.enter(funcName, config.params);
try {
me.checkAdminOnly(funcName, config);
me.logger.info("executeFunction(): timeZone=" + ixConnect.loginResult.clientInfo.timeZone + ", callId=" + ixConnect.loginResult.clientInfo.callId);
func = sol.create(funcName, config.params);
result = func.process();
} catch (ex) {
sol.common.ExceptionUtils.logAsException(ex, { logger: me.logger });
result = { exception: sol.common.ExceptionUtils.parseException(ex) };
}
me.logger.exit(funcName, result);
if (!result) {
me.logger.info("Function '" + funcName + "' must provide a result");
}
if (config.rawResult) {
result = new java.lang.String(result);
} else {
result = JSON.stringify(result);
}
me.logger.info("result=" + result);
ruleset.statusMessage = result;
},
/**
* Checks wether the function is called by an administrative user
* @param {String} funcName Function name
* @param {Object} config Configuration
*/
checkAdminOnly: function (funcName, config) {
var me = this,
isAdmin = false,
param3Obj, ticket, logTicket;
config = config || {};
if (config.adminOnly) {
if (EM_PARAM3) {
try {
param3Obj = JSON.parse(EM_PARAM3);
} catch (ignore) {
}
}
if (param3Obj && param3Obj.ticket) {
ticket = param3Obj.ticket + "";
logTicket = ticket.substr(0, 10) + "...";
param3Obj.ticket = logTicket;
isAdmin = sol.common.UserUtils.isMainAdminTicket(ticket);
me.logger.debug(["checkAdminOnly: ticket={0}, result={1}", logTicket, isAdmin]);
if (!isAdmin) {
throw "The ELOas function '" + funcName + "' can only be called with administrative rights. ticket=" + logTicket;
}
} else {
if (EM_USERID > -1) {
isAdmin = sol.common.UserUtils.isMainAdmin(EM_USERID);
}
me.logger.debug(["checkAdminOnly: userId={0}, result={1}", EM_USERID, isAdmin]);
if (!isAdmin) {
throw "The ELOas function '" + funcName + "' can only be called with administrative rights. userId=" + EM_USERID;
}
}
}
},
/**
* Returns the version of the ELOas
* @return {String}
*/
getAsVersion: function () {
return String(Packages.de.elo.mover.main.ASConstants.VERSION);
},
/**
* Returns true if the code runs within the ELOas debugger
* @return {Boolean}
*/
isDebugger: function () {
return !!Packages.de.elo.mover.main.DebuggerConstants;
},
/**
* Download fonts
* @param {Object} params Parameters
* @param {String[]} params.fontFolderRepoPaths Font folder repository path
* @return {String[]} Font temporary directory paths
*/
downloadFonts: function (params) {
var me = this,
downloadCounter = 0,
fontFiles, fontFolderObjId, i, fontFolderRepoPath, j, fontFile;
params = params || {};
params.fontFolderRepoPaths = params.fontFolderRepoPaths || ["ARCPATH[(E10E1000-E100-E100-E100-E10E10E10E00)]:/ELOas Base/Fonts"];
me.fontFolderRepoPathDownloaded = me.fontFolderRepoPathDownloaded || [];
me.fontTempDirPath = me.fontTempDirPath || sol.common.FileUtils.getTempDirPath() + File.separator + "ELOasFonts";
for (i = 0; i < params.fontFolderRepoPaths.length; i++) {
fontFolderRepoPath = params.fontFolderRepoPaths[i];
me.logger.debug("cache={0}, fontFolderRepoPath={1}", me.fontFolderRepoPathDownloaded, fontFolderRepoPath);
if (me.fontFolderRepoPathDownloaded.indexOf(fontFolderRepoPath) > -1) {
me.logger.debug(["Fonts already downloaded: fontFolderRepoPath={0}", fontFolderRepoPath]);
continue;
}
fontFolderObjId = sol.common.RepoUtils.getObjId(fontFolderRepoPath);
if (!fontFolderObjId) {
me.logger.warn(["Font folder not found: {0}", fontFolderRepoPath]);
continue;
}
me.logger.debug(["Download font files: fontFolderRepoPath={0}", fontFolderRepoPath]);
fontFiles = sol.common.FileUtils.downloadDocuments(fontFolderObjId, me.fontTempDirPath, { makeDstDirs: true, includeReferences: true });
for (j = 0; j < fontFiles.length; j++) {
fontFile = fontFiles[j];
me.logger.debug(["Font file downloaded: {0}", fontFile.canonicalPath]);
downloadCounter++;
}
me.fontFolderRepoPathDownloaded.push(fontFolderRepoPath);
}
me.logger.info(["Downloaded font files available: fontDir={0}, numberOfDownloadedFonts={1}", me.fontTempDirPath, downloadCounter]);
return me.fontTempDirPath;
}
});